import javax.jws.Oneway;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 26727
 * Date: 2024-03-03
 * Time: 10:15
 */

//函数式接口
@FunctionalInterface
//无参数
interface NoParameterNoReturn {
    //注意：只能有一个抽象方法
    void test();
}

//一个参数
interface OneParameterNoReturn {
    void test(int a);
}

//多个参数
interface TwoParameterNoReturn {
    void test(int a,int b);
}

//有返回值无参数
interface NoParameterReturn {
    //注意：只能有一个抽象方法
    int test();
}

//一个参数
interface OneParameterReturn {
    //注意：只能有一个抽象方法
    int test(int a);
}

//两个参数
interface TwoParameterReturn {
    //注意：只能有一个抽象方法
    int test(int a,int b);
}





public class Test {
    public static void main(String[] args) {
        Map<String,Integer> hashMap = new HashMap<>();
        hashMap.put("hello",3);
        hashMap.put("abc",2);
        hashMap.put("this",5);

        /*hashMap.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key: "+ s +" val: "+integer);
            }
        });*/
        hashMap.forEach((String s,Integer integer)->System.out.println("key: "+ s +" val: "+integer));
    }

    public static void main5(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("this");
        list.add("day");
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println("=========================");
        list.forEach(s->System.out.println(s));
        System.out.println("=========================");
       /* list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });*/
        list.sort((o1,o2)->{return o1.compareTo(o2);});
        list.forEach(s->System.out.println(s));
    }

    public static void main4(String[] args) {
        int a = 10;//必须是常量或者从未被修改过，才能捕获到
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("hello->"+a);
            }
        };
        noParameterNoReturn.test();
    }
    public static void main3(String[] args) {
        NoParameterReturn noParameterReturn = ()->{return 10;};//可以省略return
        int ret = noParameterReturn.test();
        System.out.println(ret);

        OneParameterReturn oneParameterReturn = x->{return x+10;};
        int ret1 = oneParameterReturn.test(9);
        System.out.println(ret1);

        TwoParameterReturn twoParameterReturn = (x,y)->{return x+y;};
        int ret2 = twoParameterReturn.test(11,12);
        System.out.println(ret2);
    }

    public static void main2(String[] args) {
        //Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法。
        NoParameterNoReturn noParameterNoReturn = ()->System.out.println("hello");
        noParameterNoReturn.test();

        OneParameterNoReturn oneParameterNoReturn = (x)->System.out.println(x+10);//参数类型只有一个可以省略类型，括号也可以省略
        oneParameterNoReturn.test(19);

        TwoParameterNoReturn twoParameterNoReturn = (int x,int y)->System.out.println(x+y); //括号不能省略,类型不能省略，除非一起省略
        twoParameterNoReturn.test(10,20);
    }

    public static void main1(String[] args) {
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("hello");
            }
        };
        noParameterNoReturn.test();
    }
}
